// $ANTLR 3.1.1 RiseCollectionFormulaClientAST.g 2009-03-10 11:17:09

package cn.newtest.bi.collection.formula.antlr;


import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.antlr.runtime.BitSet;
import org.antlr.runtime.EarlyExitException;
import org.antlr.runtime.MismatchedSetException;
import org.antlr.runtime.NoViableAltException;
import org.antlr.runtime.RecognitionException;
import org.antlr.runtime.RecognizerSharedState;
import org.antlr.runtime.Token;
import org.antlr.runtime.tree.CommonTree;
import org.antlr.runtime.tree.Tree;
import org.antlr.runtime.tree.TreeNodeStream;
import org.antlr.runtime.tree.TreeParser;
import org.antlr.runtime.tree.TreeRuleReturnScope;
public class RiseCollectionFormulaClientAST extends TreeParser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "DECINODE", "FOR", "ENDFOR", "FOREACH", "ENDFOREACH", "IF", "ENDIF", "ELSE", "Identifier", "AS", "SURE", "StringLiteral", "IN", "DecimalLiteral", "TO", "INDICATIONCELL", "RANGECELL", "ZZJGDM", "TBR", "BGQ", "TBRQ", "QYMC", "LEN", "NOTEMPTY", "EMPTY", "ENDPROG", "RPCELL", "Letter", "FloatingPointLiteral", "CharacterLiteral", "EscapeSequence", "UnicodeEscape", "OctalEscape", "HexDigit", "WS", "COMMENT", "LINE_COMMENT", "'='", "'('", "','", "')'", "'['", "']'", "'||'", "'&&'", "'=='", "'!='", "'>='", "'<='", "'>'", "'<'", "'+'", "'-'", "'*'", "'/'", "'%'", "'null'", "'true'", "'false'"
    };
    public static final int T__62=62;
    public static final int CharacterLiteral=33;
    public static final int TBR=22;
    public static final int SURE=14;
    public static final int TBRQ=24;
    public static final int RANGECELL=20;
    public static final int INDICATIONCELL=19;
    public static final int FOR=5;
    public static final int T__61=61;
    public static final int T__60=60;
    public static final int EOF=-1;
    public static final int HexDigit=37;
    public static final int Identifier=12;
    public static final int IF=9;
    public static final int T__55=55;
    public static final int AS=13;
    public static final int T__56=56;
    public static final int T__57=57;
    public static final int T__58=58;
    public static final int T__51=51;
    public static final int T__52=52;
    public static final int IN=16;
    public static final int T__53=53;
    public static final int T__54=54;
    public static final int ENDPROG=29;
    public static final int T__59=59;
    public static final int RPCELL=30;
    public static final int ENDIF=10;
    public static final int ZZJGDM=21;
    public static final int QYMC=25;
    public static final int DECINODE=4;
    public static final int BGQ=23;
    public static final int COMMENT=39;
    public static final int T__50=50;
    public static final int T__42=42;
    public static final int T__43=43;
    public static final int ENDFOR=6;
    public static final int T__41=41;
    public static final int T__46=46;
    public static final int T__47=47;
    public static final int T__44=44;
    public static final int T__45=45;
    public static final int TO=18;
    public static final int LINE_COMMENT=40;
    public static final int T__48=48;
    public static final int T__49=49;
    public static final int NOTEMPTY=27;
    public static final int ELSE=11;
    public static final int DecimalLiteral=17;
    public static final int EMPTY=28;
    public static final int StringLiteral=15;
    public static final int WS=38;
    public static final int ENDFOREACH=8;
    public static final int UnicodeEscape=35;
    public static final int FloatingPointLiteral=32;
    public static final int LEN=26;
    public static final int FOREACH=7;
    public static final int Letter=31;
    public static final int EscapeSequence=34;
    public static final int OctalEscape=36;

    // delegates
    // delegators


        public RiseCollectionFormulaClientAST(TreeNodeStream input) {
            this(input, new RecognizerSharedState());
        }
        public RiseCollectionFormulaClientAST(TreeNodeStream input, RecognizerSharedState state) {
            super(input, state);
             
        }
        

    public String[] getTokenNames() { return RiseCollectionFormulaClientAST.tokenNames; }
    public String getGrammarFileName() { return "RiseCollectionFormulaClientAST.g"; }


    	Map memory = new HashMap();
    	StringBuffer sb = new StringBuffer();
    	
    	protected void out(String s) {
    		sb.append(s);
    	}
    	
    	public String getOut() {
    		return sb.toString();
    	}
    	
    	protected void separator(CommonTree n, String sep) {
    		if(n.getToken().getTokenIndex()!=n.getParent().getTokenStopIndex())
    			out(sep);
    	}
    	
    	protected String getCells(CommonTree n) {
    	    	List<String> cells = new ArrayList<String>();
    	    	this.getAllSubTree(n, cells);
    	    	String reValue = "";
    	    	for(int i=0;i<cells.size();i++){
    	    		if(reValue.equals(""))
    	    			reValue = cells.get(i);
    	    		else
    	    			reValue += "@@@"+cells.get(i);
    	    	}
    	    	return reValue;
        	}
        	
    	private void getAllSubTree(CommonTree n,List<String> cells){
    		int count = n.getChildCount();
    		for(int i=0;i<count;i++){
    			Tree tree = n.getChild(i);
    			if(tree.getType()==RANGECELL||tree.getType()==INDICATIONCELL){
        				cells.add(tree.toString());
        			}
        		this.getAllSubTree((CommonTree)tree, cells);
        		}
    	}



    // $ANTLR start "prog"
    // RiseCollectionFormulaClientAST.g:55:1: prog : ( statement )+ ENDPROG ;
    public final void prog() throws RecognitionException {
        try {
            // RiseCollectionFormulaClientAST.g:55:6: ( ( statement )+ ENDPROG )
            // RiseCollectionFormulaClientAST.g:55:8: ( statement )+ ENDPROG
            {
            // RiseCollectionFormulaClientAST.g:55:8: ( statement )+
            int cnt1=0;
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( (LA1_0==FOR||LA1_0==FOREACH||LA1_0==IF||LA1_0==Identifier||LA1_0==SURE||LA1_0==41) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // RiseCollectionFormulaClientAST.g:0:0: statement
            	    {
            	    pushFollow(FOLLOW_statement_in_prog56);
            	    statement();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    if ( cnt1 >= 1 ) break loop1;
            	    if (state.backtracking>0) {state.failed=true; return ;}
                        EarlyExitException eee =
                            new EarlyExitException(1, input);
                        throw eee;
                }
                cnt1++;
            } while (true);

            match(input,ENDPROG,FOLLOW_ENDPROG_in_prog59); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "prog"


    // $ANTLR start "statement"
    // RiseCollectionFormulaClientAST.g:58:1: statement : ( ifStatement | ^( FOR inListStatement ( statement )* ) | ^( FOREACH ( statement )* ) | assignStatement | asAssignStatement | functionStatement );
    public final void statement() throws RecognitionException {
        try {
            // RiseCollectionFormulaClientAST.g:59:2: ( ifStatement | ^( FOR inListStatement ( statement )* ) | ^( FOREACH ( statement )* ) | assignStatement | asAssignStatement | functionStatement )
            int alt4=6;
            switch ( input.LA(1) ) {
            case IF:
                {
                alt4=1;
                }
                break;
            case FOR:
                {
                alt4=2;
                }
                break;
            case FOREACH:
                {
                alt4=3;
                }
                break;
            case 41:
                {
                alt4=4;
                }
                break;
            case Identifier:
                {
                alt4=5;
                }
                break;
            case SURE:
                {
                alt4=6;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 4, 0, input);

                throw nvae;
            }

            switch (alt4) {
                case 1 :
                    // RiseCollectionFormulaClientAST.g:59:4: ifStatement
                    {
                    pushFollow(FOLLOW_ifStatement_in_statement70);
                    ifStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // RiseCollectionFormulaClientAST.g:60:4: ^( FOR inListStatement ( statement )* )
                    {
                    match(input,FOR,FOLLOW_FOR_in_statement76); if (state.failed) return ;

                    match(input, Token.DOWN, null); if (state.failed) return ;
                    pushFollow(FOLLOW_inListStatement_in_statement78);
                    inListStatement();

                    state._fsp--;
                    if (state.failed) return ;
                    // RiseCollectionFormulaClientAST.g:60:26: ( statement )*
                    loop2:
                    do {
                        int alt2=2;
                        int LA2_0 = input.LA(1);

                        if ( (LA2_0==FOR||LA2_0==FOREACH||LA2_0==IF||LA2_0==Identifier||LA2_0==SURE||LA2_0==41) ) {
                            alt2=1;
                        }


                        switch (alt2) {
                    	case 1 :
                    	    // RiseCollectionFormulaClientAST.g:0:0: statement
                    	    {
                    	    pushFollow(FOLLOW_statement_in_statement80);
                    	    statement();

                    	    state._fsp--;
                    	    if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop2;
                        }
                    } while (true);

                    if ( state.backtracking==0 ) {
                      out("}\r");
                    }

                    match(input, Token.UP, null); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    // RiseCollectionFormulaClientAST.g:61:4: ^( FOREACH ( statement )* )
                    {
                    match(input,FOREACH,FOLLOW_FOREACH_in_statement90); if (state.failed) return ;

                    if ( state.backtracking==0 ) {

                      	    		out("{\r");
                      	    		
                      			out("var map = new Hash()\r");
                      			out("var b = false\r");
                      			out("var i = 0\r");
                      			out("while(!b){\r");
                      	    	
                    }

                    if ( input.LA(1)==Token.DOWN ) {
                        match(input, Token.DOWN, null); if (state.failed) return ;
                        // RiseCollectionFormulaClientAST.g:70:7: ( statement )*
                        loop3:
                        do {
                            int alt3=2;
                            int LA3_0 = input.LA(1);

                            if ( (LA3_0==FOR||LA3_0==FOREACH||LA3_0==IF||LA3_0==Identifier||LA3_0==SURE||LA3_0==41) ) {
                                alt3=1;
                            }


                            switch (alt3) {
                        	case 1 :
                        	    // RiseCollectionFormulaClientAST.g:0:0: statement
                        	    {
                        	    pushFollow(FOLLOW_statement_in_statement106);
                        	    statement();

                        	    state._fsp--;
                        	    if (state.failed) return ;

                        	    }
                        	    break;

                        	default :
                        	    break loop3;
                            }
                        } while (true);


                        match(input, Token.UP, null); if (state.failed) return ;
                    }
                    if ( state.backtracking==0 ) {

                      	    		out("logicValidator.setExitCode(map)\r");
                      	    		out("b=map.find(\"exitCode\")\r");
                      	    		out("if(b==null)\r");
                      			out("b=true\r");
                      			out("if(i==2000)\r");
                      			out("b = true\r");
                      			out("else\r");
                      			out("i++\r");
                      			out("}\r");
                      			
                      			out("}\r");
                      					
                      	    	
                    }

                    }
                    break;
                case 4 :
                    // RiseCollectionFormulaClientAST.g:85:5: assignStatement
                    {
                    pushFollow(FOLLOW_assignStatement_in_statement122);
                    assignStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 5 :
                    // RiseCollectionFormulaClientAST.g:86:4: asAssignStatement
                    {
                    pushFollow(FOLLOW_asAssignStatement_in_statement127);
                    asAssignStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 6 :
                    // RiseCollectionFormulaClientAST.g:87:4: functionStatement
                    {
                    pushFollow(FOLLOW_functionStatement_in_statement132);
                    functionStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "statement"


    // $ANTLR start "ifStatement"
    // RiseCollectionFormulaClientAST.g:91:1: ifStatement : ^( IF expression ( statement )* ( elseStatement )? ) ;
    public final void ifStatement() throws RecognitionException {
        try {
            // RiseCollectionFormulaClientAST.g:92:2: ( ^( IF expression ( statement )* ( elseStatement )? ) )
            // RiseCollectionFormulaClientAST.g:92:4: ^( IF expression ( statement )* ( elseStatement )? )
            {
            match(input,IF,FOLLOW_IF_in_ifStatement147); if (state.failed) return ;

            if ( state.backtracking==0 ) {
              out("if(");
            }

            match(input, Token.DOWN, null); if (state.failed) return ;
            pushFollow(FOLLOW_expression_in_ifStatement151);
            expression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
              out("){\r");
            }
            // RiseCollectionFormulaClientAST.g:92:49: ( statement )*
            loop5:
            do {
                int alt5=2;
                int LA5_0 = input.LA(1);

                if ( (LA5_0==FOR||LA5_0==FOREACH||LA5_0==IF||LA5_0==Identifier||LA5_0==SURE||LA5_0==41) ) {
                    alt5=1;
                }


                switch (alt5) {
            	case 1 :
            	    // RiseCollectionFormulaClientAST.g:0:0: statement
            	    {
            	    pushFollow(FOLLOW_statement_in_ifStatement155);
            	    statement();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop5;
                }
            } while (true);

            if ( state.backtracking==0 ) {
              out("}else{\r");
            }
            // RiseCollectionFormulaClientAST.g:92:79: ( elseStatement )?
            int alt6=2;
            int LA6_0 = input.LA(1);

            if ( (LA6_0==ELSE) ) {
                alt6=1;
            }
            switch (alt6) {
                case 1 :
                    // RiseCollectionFormulaClientAST.g:0:0: elseStatement
                    {
                    pushFollow(FOLLOW_elseStatement_in_ifStatement160);
                    elseStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
              out("}\r");
            }

            match(input, Token.UP, null); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "ifStatement"


    // $ANTLR start "elseStatement"
    // RiseCollectionFormulaClientAST.g:95:1: elseStatement : ^( ELSE ( statement )* ) ;
    public final void elseStatement() throws RecognitionException {
        try {
            // RiseCollectionFormulaClientAST.g:96:2: ( ^( ELSE ( statement )* ) )
            // RiseCollectionFormulaClientAST.g:96:4: ^( ELSE ( statement )* )
            {
            match(input,ELSE,FOLLOW_ELSE_in_elseStatement177); if (state.failed) return ;

            if ( input.LA(1)==Token.DOWN ) {
                match(input, Token.DOWN, null); if (state.failed) return ;
                // RiseCollectionFormulaClientAST.g:96:11: ( statement )*
                loop7:
                do {
                    int alt7=2;
                    int LA7_0 = input.LA(1);

                    if ( (LA7_0==FOR||LA7_0==FOREACH||LA7_0==IF||LA7_0==Identifier||LA7_0==SURE||LA7_0==41) ) {
                        alt7=1;
                    }


                    switch (alt7) {
                	case 1 :
                	    // RiseCollectionFormulaClientAST.g:0:0: statement
                	    {
                	    pushFollow(FOLLOW_statement_in_elseStatement179);
                	    statement();

                	    state._fsp--;
                	    if (state.failed) return ;

                	    }
                	    break;

                	default :
                	    break loop7;
                    }
                } while (true);


                match(input, Token.UP, null); if (state.failed) return ;
            }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "elseStatement"


    // $ANTLR start "assignStatement"
    // RiseCollectionFormulaClientAST.g:99:1: assignStatement : ^( '=' ak= assignkeywords refe= referenceassign ) ;
    public final void assignStatement() throws RecognitionException {
        String ak = null;

        String refe = null;


        try {
            // RiseCollectionFormulaClientAST.g:100:2: ( ^( '=' ak= assignkeywords refe= referenceassign ) )
            // RiseCollectionFormulaClientAST.g:100:4: ^( '=' ak= assignkeywords refe= referenceassign )
            {
            match(input,41,FOLLOW_41_in_assignStatement194); if (state.failed) return ;

            match(input, Token.DOWN, null); if (state.failed) return ;
            pushFollow(FOLLOW_assignkeywords_in_assignStatement198);
            ak=assignkeywords();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_referenceassign_in_assignStatement202);
            refe=referenceassign();

            state._fsp--;
            if (state.failed) return ;

            match(input, Token.UP, null); if (state.failed) return ;
            if ( state.backtracking==0 ) {

              			out("assign(\""+ak+"\","+refe+")\r");
              		
            }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "assignStatement"


    // $ANTLR start "asAssignStatement"
    // RiseCollectionFormulaClientAST.g:106:1: asAssignStatement : ^(id1= Identifier id2= Identifier ) ;
    public final void asAssignStatement() throws RecognitionException {
        CommonTree id1=null;
        CommonTree id2=null;

        try {
            // RiseCollectionFormulaClientAST.g:107:2: ( ^(id1= Identifier id2= Identifier ) )
            // RiseCollectionFormulaClientAST.g:107:4: ^(id1= Identifier id2= Identifier )
            {
            id1=(CommonTree)match(input,Identifier,FOLLOW_Identifier_in_asAssignStatement222); if (state.failed) return ;

            match(input, Token.DOWN, null); if (state.failed) return ;
            id2=(CommonTree)match(input,Identifier,FOLLOW_Identifier_in_asAssignStatement226); if (state.failed) return ;

            match(input, Token.UP, null); if (state.failed) return ;
            if ( state.backtracking==0 ) {

              			out("logicValidator.proAlias.add(\""+id1+"\",\""+id2+"\")\r");
              			out("logicValidator.proAliasReverse.add(\""+id2+"\",\""+id1+"\")\r");
              		
            }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "asAssignStatement"


    // $ANTLR start "functionStatement"
    // RiseCollectionFormulaClientAST.g:114:1: functionStatement : ^( SURE ex= expression st= StringLiteral ) ;
    public final void functionStatement() throws RecognitionException {
        CommonTree st=null;
        RiseCollectionFormulaClientAST.expression_return ex = null;


        try {
            // RiseCollectionFormulaClientAST.g:115:2: ( ^( SURE ex= expression st= StringLiteral ) )
            // RiseCollectionFormulaClientAST.g:115:4: ^( SURE ex= expression st= StringLiteral )
            {
            match(input,SURE,FOLLOW_SURE_in_functionStatement245); if (state.failed) return ;

            if ( state.backtracking==0 ) {

              				out("try{\r");
              				out("logicValidator.sure(");
              			
            }

            match(input, Token.DOWN, null); if (state.failed) return ;
            pushFollow(FOLLOW_expression_in_functionStatement264);
            ex=expression();

            state._fsp--;
            if (state.failed) return ;
            st=(CommonTree)match(input,StringLiteral,FOLLOW_StringLiteral_in_functionStatement268); if (state.failed) return ;

            match(input, Token.UP, null); if (state.failed) return ;
            if ( state.backtracking==0 ) {

              				out(","+(st!=null?st.getText():null)+",\"");
              				String cells = getCells((ex!=null?((CommonTree)ex.start):null));
              				out(cells);
              				out("\")\r");
              				out("}catch(ex){\r");
              				out("logicValidator.addErrors("+(st!=null?st.getText():null)+",\""+cells+"\")\r");
              				out("}\r");
              			
            }

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "functionStatement"


    // $ANTLR start "inListStatement"
    // RiseCollectionFormulaClientAST.g:133:1: inListStatement : ( ^( IN Identifier ^( TO de1= DecimalLiteral de2= DecimalLiteral ) (de3= DecimalLiteral )? ) | ^( IN Identifier ^( DECINODE ( DecimalLiteral )+ ) ) );
    public final void inListStatement() throws RecognitionException {
        CommonTree de1=null;
        CommonTree de2=null;
        CommonTree de3=null;
        CommonTree Identifier1=null;
        CommonTree DECINODE2=null;
        CommonTree Identifier3=null;

        try {
            // RiseCollectionFormulaClientAST.g:134:2: ( ^( IN Identifier ^( TO de1= DecimalLiteral de2= DecimalLiteral ) (de3= DecimalLiteral )? ) | ^( IN Identifier ^( DECINODE ( DecimalLiteral )+ ) ) )
            int alt10=2;
            int LA10_0 = input.LA(1);

            if ( (LA10_0==IN) ) {
                int LA10_1 = input.LA(2);

                if ( (LA10_1==DOWN) ) {
                    int LA10_2 = input.LA(3);

                    if ( (LA10_2==Identifier) ) {
                        int LA10_3 = input.LA(4);

                        if ( (LA10_3==TO) ) {
                            alt10=1;
                        }
                        else if ( (LA10_3==DECINODE) ) {
                            alt10=2;
                        }
                        else {
                            if (state.backtracking>0) {state.failed=true; return ;}
                            NoViableAltException nvae =
                                new NoViableAltException("", 10, 3, input);

                            throw nvae;
                        }
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 10, 2, input);

                        throw nvae;
                    }
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 10, 1, input);

                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 10, 0, input);

                throw nvae;
            }
            switch (alt10) {
                case 1 :
                    // RiseCollectionFormulaClientAST.g:134:4: ^( IN Identifier ^( TO de1= DecimalLiteral de2= DecimalLiteral ) (de3= DecimalLiteral )? )
                    {
                    match(input,IN,FOLLOW_IN_in_inListStatement287); if (state.failed) return ;

                    match(input, Token.DOWN, null); if (state.failed) return ;
                    Identifier1=(CommonTree)match(input,Identifier,FOLLOW_Identifier_in_inListStatement289); if (state.failed) return ;
                    match(input,TO,FOLLOW_TO_in_inListStatement292); if (state.failed) return ;

                    match(input, Token.DOWN, null); if (state.failed) return ;
                    de1=(CommonTree)match(input,DecimalLiteral,FOLLOW_DecimalLiteral_in_inListStatement296); if (state.failed) return ;
                    de2=(CommonTree)match(input,DecimalLiteral,FOLLOW_DecimalLiteral_in_inListStatement300); if (state.failed) return ;

                    match(input, Token.UP, null); if (state.failed) return ;
                    // RiseCollectionFormulaClientAST.g:134:67: (de3= DecimalLiteral )?
                    int alt8=2;
                    int LA8_0 = input.LA(1);

                    if ( (LA8_0==DecimalLiteral) ) {
                        alt8=1;
                    }
                    switch (alt8) {
                        case 1 :
                            // RiseCollectionFormulaClientAST.g:0:0: de3= DecimalLiteral
                            {
                            de3=(CommonTree)match(input,DecimalLiteral,FOLLOW_DecimalLiteral_in_inListStatement305); if (state.failed) return ;

                            }
                            break;

                    }


                    match(input, Token.UP, null); if (state.failed) return ;
                    if ( state.backtracking==0 ) {

                      			String i = "1";
                      			if(de3!=null){
                      				i = (de3!=null?de3.getText():null);
                      			}
                      			
                      			Object o = memory.get("forInListStatementList"+(Identifier1!=null?Identifier1.getText():null));
                      			if(o==null){
                      				out("def forInListStatementList"+(Identifier1!=null?Identifier1.getText():null)+" = makeInListStatementList(");
                      				memory.put("forInListStatementList"+(Identifier1!=null?Identifier1.getText():null),"0");
                      			}else{
                      				out("forInListStatementList"+(Identifier1!=null?Identifier1.getText():null)+" = makeInListStatementList(");
                      			}
                      				
                      			out("\""+(de1!=null?de1.getText():null)+"\",\""+(de2!=null?de2.getText():null)+"\","+i+")\r");
                      						
                      			out("for(");
                      			out((Identifier1!=null?Identifier1.getText():null));
                      			out(" in forInListStatementList"+(Identifier1!=null?Identifier1.getText():null)+"){\r");
                      			out("localVariables.put(\"");
                      			out((Identifier1!=null?Identifier1.getText():null));
                      			out("\",");
                      			out((Identifier1!=null?Identifier1.getText():null));
                      			out(")\r");
                      		
                    }

                    }
                    break;
                case 2 :
                    // RiseCollectionFormulaClientAST.g:160:4: ^( IN Identifier ^( DECINODE ( DecimalLiteral )+ ) )
                    {
                    match(input,IN,FOLLOW_IN_in_inListStatement317); if (state.failed) return ;

                    match(input, Token.DOWN, null); if (state.failed) return ;
                    Identifier3=(CommonTree)match(input,Identifier,FOLLOW_Identifier_in_inListStatement319); if (state.failed) return ;
                    DECINODE2=(CommonTree)match(input,DECINODE,FOLLOW_DECINODE_in_inListStatement322); if (state.failed) return ;

                    match(input, Token.DOWN, null); if (state.failed) return ;
                    // RiseCollectionFormulaClientAST.g:160:31: ( DecimalLiteral )+
                    int cnt9=0;
                    loop9:
                    do {
                        int alt9=2;
                        int LA9_0 = input.LA(1);

                        if ( (LA9_0==DecimalLiteral) ) {
                            alt9=1;
                        }


                        switch (alt9) {
                    	case 1 :
                    	    // RiseCollectionFormulaClientAST.g:0:0: DecimalLiteral
                    	    {
                    	    match(input,DecimalLiteral,FOLLOW_DecimalLiteral_in_inListStatement324); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt9 >= 1 ) break loop9;
                    	    if (state.backtracking>0) {state.failed=true; return ;}
                                EarlyExitException eee =
                                    new EarlyExitException(9, input);
                                throw eee;
                        }
                        cnt9++;
                    } while (true);


                    match(input, Token.UP, null); if (state.failed) return ;

                    match(input, Token.UP, null); if (state.failed) return ;
                    if ( state.backtracking==0 ) {

                      			CommonTree ct = DECINODE2;
                      			int count = ct.getChildCount();
                                         	for(int i=0;i<count;i++){
                                         		System.out.println("3============================="+ct.getChild(i).getText());
                                         	}
                                         	
                                         	//for(Identifier3 in list)
                      		
                    }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "inListStatement"

    public static class expression_return extends TreeRuleReturnScope {
    };

    // $ANTLR start "expression"
    // RiseCollectionFormulaClientAST.g:172:1: expression : ( ^( '||' expression expression ) | ^( '&&' expression expression ) | ^( '==' expression expression ) | ^( '>=' expression expression ) | ^( '<=' expression expression ) | ^( '>' expression expression ) | ^( '<' expression expression ) | ^( '!=' expression expression ) | ^( '+' expression expression ) | ^( '-' expression expression ) | ^( '*' expression expression ) | ^( '/' expression expression ) | ^( '%' expression expression ) | primary );
    public final RiseCollectionFormulaClientAST.expression_return expression() throws RecognitionException {
        RiseCollectionFormulaClientAST.expression_return retval = new RiseCollectionFormulaClientAST.expression_return();
        retval.start = input.LT(1);

        try {
            // RiseCollectionFormulaClientAST.g:173:2: ( ^( '||' expression expression ) | ^( '&&' expression expression ) | ^( '==' expression expression ) | ^( '>=' expression expression ) | ^( '<=' expression expression ) | ^( '>' expression expression ) | ^( '<' expression expression ) | ^( '!=' expression expression ) | ^( '+' expression expression ) | ^( '-' expression expression ) | ^( '*' expression expression ) | ^( '/' expression expression ) | ^( '%' expression expression ) | primary )
            int alt11=14;
            switch ( input.LA(1) ) {
            case 47:
                {
                alt11=1;
                }
                break;
            case 48:
                {
                alt11=2;
                }
                break;
            case 49:
                {
                alt11=3;
                }
                break;
            case 51:
                {
                alt11=4;
                }
                break;
            case 52:
                {
                alt11=5;
                }
                break;
            case 53:
                {
                alt11=6;
                }
                break;
            case 54:
                {
                alt11=7;
                }
                break;
            case 50:
                {
                alt11=8;
                }
                break;
            case 55:
                {
                alt11=9;
                }
                break;
            case 56:
                {
                alt11=10;
                }
                break;
            case 57:
                {
                alt11=11;
                }
                break;
            case 58:
                {
                alt11=12;
                }
                break;
            case 59:
                {
                alt11=13;
                }
                break;
            case Identifier:
            case StringLiteral:
            case DecimalLiteral:
            case INDICATIONCELL:
            case RANGECELL:
            case ZZJGDM:
            case TBR:
            case BGQ:
            case TBRQ:
            case QYMC:
            case LEN:
            case NOTEMPTY:
            case EMPTY:
            case FloatingPointLiteral:
            case CharacterLiteral:
            case 42:
            case 60:
            case 61:
            case 62:
                {
                alt11=14;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 11, 0, input);

                throw nvae;
            }

            switch (alt11) {
                case 1 :
                    // RiseCollectionFormulaClientAST.g:173:4: ^( '||' expression expression )
                    {
                    match(input,47,FOLLOW_47_in_expression344); if (state.failed) return retval;

                    match(input, Token.DOWN, null); if (state.failed) return retval;
                    pushFollow(FOLLOW_expression_in_expression346);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                      out("||");
                    }
                    pushFollow(FOLLOW_expression_in_expression350);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;

                    match(input, Token.UP, null); if (state.failed) return retval;

                    }
                    break;
                case 2 :
                    // RiseCollectionFormulaClientAST.g:174:4: ^( '&&' expression expression )
                    {
                    match(input,48,FOLLOW_48_in_expression357); if (state.failed) return retval;

                    match(input, Token.DOWN, null); if (state.failed) return retval;
                    pushFollow(FOLLOW_expression_in_expression359);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                      out("&&");
                    }
                    pushFollow(FOLLOW_expression_in_expression363);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;

                    match(input, Token.UP, null); if (state.failed) return retval;

                    }
                    break;
                case 3 :
                    // RiseCollectionFormulaClientAST.g:175:4: ^( '==' expression expression )
                    {
                    match(input,49,FOLLOW_49_in_expression370); if (state.failed) return retval;

                    match(input, Token.DOWN, null); if (state.failed) return retval;
                    pushFollow(FOLLOW_expression_in_expression372);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                      out("==");
                    }
                    pushFollow(FOLLOW_expression_in_expression376);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;

                    match(input, Token.UP, null); if (state.failed) return retval;

                    }
                    break;
                case 4 :
                    // RiseCollectionFormulaClientAST.g:176:4: ^( '>=' expression expression )
                    {
                    match(input,51,FOLLOW_51_in_expression383); if (state.failed) return retval;

                    match(input, Token.DOWN, null); if (state.failed) return retval;
                    pushFollow(FOLLOW_expression_in_expression385);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                      out(">=");
                    }
                    pushFollow(FOLLOW_expression_in_expression389);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;

                    match(input, Token.UP, null); if (state.failed) return retval;

                    }
                    break;
                case 5 :
                    // RiseCollectionFormulaClientAST.g:177:4: ^( '<=' expression expression )
                    {
                    match(input,52,FOLLOW_52_in_expression396); if (state.failed) return retval;

                    match(input, Token.DOWN, null); if (state.failed) return retval;
                    pushFollow(FOLLOW_expression_in_expression398);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                      out("<=");
                    }
                    pushFollow(FOLLOW_expression_in_expression402);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;

                    match(input, Token.UP, null); if (state.failed) return retval;

                    }
                    break;
                case 6 :
                    // RiseCollectionFormulaClientAST.g:178:4: ^( '>' expression expression )
                    {
                    match(input,53,FOLLOW_53_in_expression409); if (state.failed) return retval;

                    match(input, Token.DOWN, null); if (state.failed) return retval;
                    pushFollow(FOLLOW_expression_in_expression411);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                      out(">");
                    }
                    pushFollow(FOLLOW_expression_in_expression415);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;

                    match(input, Token.UP, null); if (state.failed) return retval;

                    }
                    break;
                case 7 :
                    // RiseCollectionFormulaClientAST.g:179:4: ^( '<' expression expression )
                    {
                    match(input,54,FOLLOW_54_in_expression422); if (state.failed) return retval;

                    match(input, Token.DOWN, null); if (state.failed) return retval;
                    pushFollow(FOLLOW_expression_in_expression424);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                      out("<");
                    }
                    pushFollow(FOLLOW_expression_in_expression428);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;

                    match(input, Token.UP, null); if (state.failed) return retval;

                    }
                    break;
                case 8 :
                    // RiseCollectionFormulaClientAST.g:180:4: ^( '!=' expression expression )
                    {
                    match(input,50,FOLLOW_50_in_expression435); if (state.failed) return retval;

                    match(input, Token.DOWN, null); if (state.failed) return retval;
                    pushFollow(FOLLOW_expression_in_expression437);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                      out("!=");
                    }
                    pushFollow(FOLLOW_expression_in_expression441);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;

                    match(input, Token.UP, null); if (state.failed) return retval;

                    }
                    break;
                case 9 :
                    // RiseCollectionFormulaClientAST.g:181:4: ^( '+' expression expression )
                    {
                    match(input,55,FOLLOW_55_in_expression448); if (state.failed) return retval;

                    match(input, Token.DOWN, null); if (state.failed) return retval;
                    pushFollow(FOLLOW_expression_in_expression450);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                      out("+");
                    }
                    pushFollow(FOLLOW_expression_in_expression454);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;

                    match(input, Token.UP, null); if (state.failed) return retval;

                    }
                    break;
                case 10 :
                    // RiseCollectionFormulaClientAST.g:182:5: ^( '-' expression expression )
                    {
                    match(input,56,FOLLOW_56_in_expression462); if (state.failed) return retval;

                    match(input, Token.DOWN, null); if (state.failed) return retval;
                    pushFollow(FOLLOW_expression_in_expression464);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                      out("-");
                    }
                    pushFollow(FOLLOW_expression_in_expression468);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;

                    match(input, Token.UP, null); if (state.failed) return retval;

                    }
                    break;
                case 11 :
                    // RiseCollectionFormulaClientAST.g:183:4: ^( '*' expression expression )
                    {
                    match(input,57,FOLLOW_57_in_expression475); if (state.failed) return retval;

                    match(input, Token.DOWN, null); if (state.failed) return retval;
                    pushFollow(FOLLOW_expression_in_expression477);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                      out("*");
                    }
                    pushFollow(FOLLOW_expression_in_expression481);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;

                    match(input, Token.UP, null); if (state.failed) return retval;

                    }
                    break;
                case 12 :
                    // RiseCollectionFormulaClientAST.g:184:6: ^( '/' expression expression )
                    {
                    match(input,58,FOLLOW_58_in_expression490); if (state.failed) return retval;

                    match(input, Token.DOWN, null); if (state.failed) return retval;
                    pushFollow(FOLLOW_expression_in_expression492);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                      out("/");
                    }
                    pushFollow(FOLLOW_expression_in_expression496);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;

                    match(input, Token.UP, null); if (state.failed) return retval;

                    }
                    break;
                case 13 :
                    // RiseCollectionFormulaClientAST.g:185:4: ^( '%' expression expression )
                    {
                    match(input,59,FOLLOW_59_in_expression503); if (state.failed) return retval;

                    match(input, Token.DOWN, null); if (state.failed) return retval;
                    pushFollow(FOLLOW_expression_in_expression505);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    pushFollow(FOLLOW_expression_in_expression507);
                    expression();

                    state._fsp--;
                    if (state.failed) return retval;

                    match(input, Token.UP, null); if (state.failed) return retval;

                    }
                    break;
                case 14 :
                    // RiseCollectionFormulaClientAST.g:186:4: primary
                    {
                    pushFollow(FOLLOW_primary_in_expression513);
                    primary();

                    state._fsp--;
                    if (state.failed) return retval;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "expression"


    // $ANTLR start "primary"
    // RiseCollectionFormulaClientAST.g:189:1: primary : ( parExpression | ^( LEN ak= assignkeywords ) | ^( NOTEMPTY ak= assignkeywords ) | ^( EMPTY ak= assignkeywords ) | Identifier | literal | reportkeywords | reference );
    public final void primary() throws RecognitionException {
        CommonTree Identifier4=null;
        String ak = null;


        try {
            // RiseCollectionFormulaClientAST.g:190:6: ( parExpression | ^( LEN ak= assignkeywords ) | ^( NOTEMPTY ak= assignkeywords ) | ^( EMPTY ak= assignkeywords ) | Identifier | literal | reportkeywords | reference )
            int alt12=8;
            switch ( input.LA(1) ) {
            case 42:
                {
                alt12=1;
                }
                break;
            case LEN:
                {
                alt12=2;
                }
                break;
            case NOTEMPTY:
                {
                alt12=3;
                }
                break;
            case EMPTY:
                {
                alt12=4;
                }
                break;
            case Identifier:
                {
                alt12=5;
                }
                break;
            case StringLiteral:
            case DecimalLiteral:
            case FloatingPointLiteral:
            case CharacterLiteral:
            case 60:
            case 61:
            case 62:
                {
                alt12=6;
                }
                break;
            case INDICATIONCELL:
            case RANGECELL:
                {
                alt12=7;
                }
                break;
            case ZZJGDM:
            case TBR:
            case BGQ:
            case TBRQ:
            case QYMC:
                {
                alt12=8;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 12, 0, input);

                throw nvae;
            }

            switch (alt12) {
                case 1 :
                    // RiseCollectionFormulaClientAST.g:190:11: parExpression
                    {
                    pushFollow(FOLLOW_parExpression_in_primary535);
                    parExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // RiseCollectionFormulaClientAST.g:191:8: ^( LEN ak= assignkeywords )
                    {
                    match(input,LEN,FOLLOW_LEN_in_primary545); if (state.failed) return ;

                    match(input, Token.DOWN, null); if (state.failed) return ;
                    pushFollow(FOLLOW_assignkeywords_in_primary549);
                    ak=assignkeywords();

                    state._fsp--;
                    if (state.failed) return ;

                    match(input, Token.UP, null); if (state.failed) return ;
                    if ( state.backtracking==0 ) {

                          			int iPos = ak.indexOf('&');
                          			if(iPos>-1){
                          				out("Integer.valueOf(len(\""+ak+"\"))");
                          			}else{
                          				String rangeCell = ak;
                          				int iPos1 = rangeCell.indexOf('[');
                      		       		int iPos2 = rangeCell.indexOf(',');
                      		       		String catalogCode = rangeCell.substring(iPos1+1,iPos2);
                      		       		if(catalogCode==null||catalogCode.equals("")){
                      			       		out("Integer.valueOf(len(\""+ak+"\",map))");
                      			       	}else{
                      			       		out("Integer.valueOf(len(\""+ak+"\"))");
                      			       	}
                          			}
                          		
                    }

                    }
                    break;
                case 3 :
                    // RiseCollectionFormulaClientAST.g:208:8: ^( NOTEMPTY ak= assignkeywords )
                    {
                    match(input,NOTEMPTY,FOLLOW_NOTEMPTY_in_primary568); if (state.failed) return ;

                    match(input, Token.DOWN, null); if (state.failed) return ;
                    pushFollow(FOLLOW_assignkeywords_in_primary572);
                    ak=assignkeywords();

                    state._fsp--;
                    if (state.failed) return ;

                    match(input, Token.UP, null); if (state.failed) return ;
                    if ( state.backtracking==0 ) {

                          			int iPos = ak.indexOf('&');
                          			if(iPos>-1){
                          				out("logicValidator.notEmpty(\""+ak+"\")");
                          			}else{
                          				String rangeCell = ak;
                          				int iPos1 = rangeCell.indexOf('[');
                      		       		int iPos2 = rangeCell.indexOf(',');
                      		       		String catalogCode = rangeCell.substring(iPos1+1,iPos2);
                      		       		if(catalogCode==null||catalogCode.equals("")){
                      			       		out("logicValidator.notEmpty(\""+ak+"\",map)");
                      			       	}else{
                      			       		out("logicValidator.notEmpty(\""+ak+"\")");
                      			       	}
                          			}
                          		
                    }

                    }
                    break;
                case 4 :
                    // RiseCollectionFormulaClientAST.g:225:8: ^( EMPTY ak= assignkeywords )
                    {
                    match(input,EMPTY,FOLLOW_EMPTY_in_primary591); if (state.failed) return ;

                    match(input, Token.DOWN, null); if (state.failed) return ;
                    pushFollow(FOLLOW_assignkeywords_in_primary595);
                    ak=assignkeywords();

                    state._fsp--;
                    if (state.failed) return ;

                    match(input, Token.UP, null); if (state.failed) return ;
                    if ( state.backtracking==0 ) {

                          			int iPos = ak.indexOf('&');
                          			if(iPos>-1){
                          				out("!notEmpty(\""+ak+"\")");
                          			}else{
                          				String rangeCell = ak;
                          				int iPos1 = rangeCell.indexOf('[');
                      		       		int iPos2 = rangeCell.indexOf(',');
                      		       		String catalogCode = rangeCell.substring(iPos1+1,iPos2);
                      		       		if(catalogCode==null||catalogCode.equals("")){
                      			       		out("!notEmpty(\""+ak+"\",map)");
                      			       	}else{
                      			       		out("!notEmpty(\""+ak+"\")");
                      			       	}
                          			}
                          		
                    }

                    }
                    break;
                case 5 :
                    // RiseCollectionFormulaClientAST.g:242:4: Identifier
                    {
                    Identifier4=(CommonTree)match(input,Identifier,FOLLOW_Identifier_in_primary609); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                      out((Identifier4!=null?Identifier4.getText():null));
                    }

                    }
                    break;
                case 6 :
                    // RiseCollectionFormulaClientAST.g:243:7: literal
                    {
                    pushFollow(FOLLOW_literal_in_primary618);
                    literal();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 7 :
                    // RiseCollectionFormulaClientAST.g:244:4: reportkeywords
                    {
                    pushFollow(FOLLOW_reportkeywords_in_primary623);
                    reportkeywords();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 8 :
                    // RiseCollectionFormulaClientAST.g:245:4: reference
                    {
                    pushFollow(FOLLOW_reference_in_primary628);
                    reference();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "primary"


    // $ANTLR start "assignkeywords"
    // RiseCollectionFormulaClientAST.g:248:1: assignkeywords returns [String value] : (indi= INDICATIONCELL | range= RANGECELL );
    public final String assignkeywords() throws RecognitionException {
        String value = null;

        CommonTree indi=null;
        CommonTree range=null;

        try {
            // RiseCollectionFormulaClientAST.g:249:2: (indi= INDICATIONCELL | range= RANGECELL )
            int alt13=2;
            int LA13_0 = input.LA(1);

            if ( (LA13_0==INDICATIONCELL) ) {
                alt13=1;
            }
            else if ( (LA13_0==RANGECELL) ) {
                alt13=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return value;}
                NoViableAltException nvae =
                    new NoViableAltException("", 13, 0, input);

                throw nvae;
            }
            switch (alt13) {
                case 1 :
                    // RiseCollectionFormulaClientAST.g:249:4: indi= INDICATIONCELL
                    {
                    indi=(CommonTree)match(input,INDICATIONCELL,FOLLOW_INDICATIONCELL_in_assignkeywords648); if (state.failed) return value;
                    if ( state.backtracking==0 ) {
                      value = (indi!=null?indi.getText():null);
                    }

                    }
                    break;
                case 2 :
                    // RiseCollectionFormulaClientAST.g:250:8: range= RANGECELL
                    {
                    range=(CommonTree)match(input,RANGECELL,FOLLOW_RANGECELL_in_assignkeywords660); if (state.failed) return value;
                    if ( state.backtracking==0 ) {
                      value = (range!=null?range.getText():null);
                    }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return value;
    }
    // $ANTLR end "assignkeywords"


    // $ANTLR start "reportkeywords"
    // RiseCollectionFormulaClientAST.g:253:1: reportkeywords : ( INDICATIONCELL | RANGECELL );
    public final void reportkeywords() throws RecognitionException {
        CommonTree INDICATIONCELL5=null;
        CommonTree RANGECELL6=null;

        try {
            // RiseCollectionFormulaClientAST.g:254:2: ( INDICATIONCELL | RANGECELL )
            int alt14=2;
            int LA14_0 = input.LA(1);

            if ( (LA14_0==INDICATIONCELL) ) {
                alt14=1;
            }
            else if ( (LA14_0==RANGECELL) ) {
                alt14=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 14, 0, input);

                throw nvae;
            }
            switch (alt14) {
                case 1 :
                    // RiseCollectionFormulaClientAST.g:254:4: INDICATIONCELL
                    {
                    INDICATIONCELL5=(CommonTree)match(input,INDICATIONCELL,FOLLOW_INDICATIONCELL_in_reportkeywords676); if (state.failed) return ;
                    if ( state.backtracking==0 ) {

                      			out("logicValidator.getIndicationValue(\""+(INDICATIONCELL5!=null?INDICATIONCELL5.getText():null)+"\")");
                      		
                    }

                    }
                    break;
                case 2 :
                    // RiseCollectionFormulaClientAST.g:258:8: RANGECELL
                    {
                    RANGECELL6=(CommonTree)match(input,RANGECELL,FOLLOW_RANGECELL_in_reportkeywords689); if (state.failed) return ;
                    if ( state.backtracking==0 ) {

                      		       	String rangeCell = (RANGECELL6!=null?RANGECELL6.getText():null);
                      		       	int iPos1 = rangeCell.indexOf('[');
                      		       	int iPos2 = rangeCell.indexOf(',');
                      		       	String catalogCode = rangeCell.substring(iPos1+1,iPos2);
                      		       	if(catalogCode==null||catalogCode.equals("")){
                      		       		out("logicValidator.getRangeCellValue(\""+(RANGECELL6!=null?RANGECELL6.getText():null)+"\",map)");
                      		       	}else{
                      		       		out("logicValidator.getRangeCellValue(\""+(RANGECELL6!=null?RANGECELL6.getText():null)+"\")");
                      		       	}
                          		
                    }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "reportkeywords"


    // $ANTLR start "referenceassign"
    // RiseCollectionFormulaClientAST.g:272:1: referenceassign returns [String value] : ( ZZJGDM | TBR | bgq= BGQ | tbrq= TBRQ | QYMC );
    public final String referenceassign() throws RecognitionException {
        String value = null;

        CommonTree bgq=null;
        CommonTree tbrq=null;

        try {
            // RiseCollectionFormulaClientAST.g:273:2: ( ZZJGDM | TBR | bgq= BGQ | tbrq= TBRQ | QYMC )
            int alt15=5;
            switch ( input.LA(1) ) {
            case ZZJGDM:
                {
                alt15=1;
                }
                break;
            case TBR:
                {
                alt15=2;
                }
                break;
            case BGQ:
                {
                alt15=3;
                }
                break;
            case TBRQ:
                {
                alt15=4;
                }
                break;
            case QYMC:
                {
                alt15=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return value;}
                NoViableAltException nvae =
                    new NoViableAltException("", 15, 0, input);

                throw nvae;
            }

            switch (alt15) {
                case 1 :
                    // RiseCollectionFormulaClientAST.g:273:4: ZZJGDM
                    {
                    match(input,ZZJGDM,FOLLOW_ZZJGDM_in_referenceassign712); if (state.failed) return value;
                    if ( state.backtracking==0 ) {
                      value = "getZZJGDM()";
                    }

                    }
                    break;
                case 2 :
                    // RiseCollectionFormulaClientAST.g:274:8: TBR
                    {
                    match(input,TBR,FOLLOW_TBR_in_referenceassign722); if (state.failed) return value;
                    if ( state.backtracking==0 ) {
                      value = "getTBR()";
                    }

                    }
                    break;
                case 3 :
                    // RiseCollectionFormulaClientAST.g:275:8: bgq= BGQ
                    {
                    bgq=(CommonTree)match(input,BGQ,FOLLOW_BGQ_in_referenceassign734); if (state.failed) return value;
                    if ( state.backtracking==0 ) {
                      value = "getBGQ(\""+(bgq!=null?bgq.getText():null)+"\")";
                    }

                    }
                    break;
                case 4 :
                    // RiseCollectionFormulaClientAST.g:276:8: tbrq= TBRQ
                    {
                    tbrq=(CommonTree)match(input,TBRQ,FOLLOW_TBRQ_in_referenceassign746); if (state.failed) return value;
                    if ( state.backtracking==0 ) {
                      value = "getTBRQ(\""+(tbrq!=null?tbrq.getText():null)+"\")";
                    }

                    }
                    break;
                case 5 :
                    // RiseCollectionFormulaClientAST.g:277:8: QYMC
                    {
                    match(input,QYMC,FOLLOW_QYMC_in_referenceassign756); if (state.failed) return value;
                    if ( state.backtracking==0 ) {
                      value = "getQYMC()";
                    }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return value;
    }
    // $ANTLR end "referenceassign"


    // $ANTLR start "reference"
    // RiseCollectionFormulaClientAST.g:280:1: reference : ( ZZJGDM | TBR | bgq= BGQ | tbrq= TBRQ | QYMC );
    public final void reference() throws RecognitionException {
        CommonTree bgq=null;
        CommonTree tbrq=null;

        try {
            // RiseCollectionFormulaClientAST.g:281:2: ( ZZJGDM | TBR | bgq= BGQ | tbrq= TBRQ | QYMC )
            int alt16=5;
            switch ( input.LA(1) ) {
            case ZZJGDM:
                {
                alt16=1;
                }
                break;
            case TBR:
                {
                alt16=2;
                }
                break;
            case BGQ:
                {
                alt16=3;
                }
                break;
            case TBRQ:
                {
                alt16=4;
                }
                break;
            case QYMC:
                {
                alt16=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 16, 0, input);

                throw nvae;
            }

            switch (alt16) {
                case 1 :
                    // RiseCollectionFormulaClientAST.g:281:4: ZZJGDM
                    {
                    match(input,ZZJGDM,FOLLOW_ZZJGDM_in_reference769); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                      out("getZZJGDM()");
                    }

                    }
                    break;
                case 2 :
                    // RiseCollectionFormulaClientAST.g:282:8: TBR
                    {
                    match(input,TBR,FOLLOW_TBR_in_reference779); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                      out("getTBR()");
                    }

                    }
                    break;
                case 3 :
                    // RiseCollectionFormulaClientAST.g:283:8: bgq= BGQ
                    {
                    bgq=(CommonTree)match(input,BGQ,FOLLOW_BGQ_in_reference791); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                      out("getBGQ(\""+(bgq!=null?bgq.getText():null)+"\")");
                    }

                    }
                    break;
                case 4 :
                    // RiseCollectionFormulaClientAST.g:284:8: tbrq= TBRQ
                    {
                    tbrq=(CommonTree)match(input,TBRQ,FOLLOW_TBRQ_in_reference803); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                      out("getTBRQ(\""+(tbrq!=null?tbrq.getText():null)+"\")");
                    }

                    }
                    break;
                case 5 :
                    // RiseCollectionFormulaClientAST.g:285:8: QYMC
                    {
                    match(input,QYMC,FOLLOW_QYMC_in_reference813); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                      out("getQYMC()");
                    }

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "reference"


    // $ANTLR start "parExpression"
    // RiseCollectionFormulaClientAST.g:288:1: parExpression : ^( '(' expression ')' ) ;
    public final void parExpression() throws RecognitionException {
        try {
            // RiseCollectionFormulaClientAST.g:289:6: ( ^( '(' expression ')' ) )
            // RiseCollectionFormulaClientAST.g:289:10: ^( '(' expression ')' )
            {
            match(input,42,FOLLOW_42_in_parExpression841); if (state.failed) return ;

            if ( state.backtracking==0 ) {
              out("(");
            }

            match(input, Token.DOWN, null); if (state.failed) return ;
            pushFollow(FOLLOW_expression_in_parExpression844);
            expression();

            state._fsp--;
            if (state.failed) return ;
            match(input,44,FOLLOW_44_in_parExpression846); if (state.failed) return ;
            if ( state.backtracking==0 ) {
              out(")");
            }

            match(input, Token.UP, null); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "parExpression"


    // $ANTLR start "literal"
    // RiseCollectionFormulaClientAST.g:292:1: literal : ( DecimalLiteral | FloatingPointLiteral | CharacterLiteral | StringLiteral | booleanLiteral | 'null' );
    public final void literal() throws RecognitionException {
        CommonTree DecimalLiteral7=null;

        try {
            // RiseCollectionFormulaClientAST.g:293:6: ( DecimalLiteral | FloatingPointLiteral | CharacterLiteral | StringLiteral | booleanLiteral | 'null' )
            int alt17=6;
            switch ( input.LA(1) ) {
            case DecimalLiteral:
                {
                alt17=1;
                }
                break;
            case FloatingPointLiteral:
                {
                alt17=2;
                }
                break;
            case CharacterLiteral:
                {
                alt17=3;
                }
                break;
            case StringLiteral:
                {
                alt17=4;
                }
                break;
            case 61:
            case 62:
                {
                alt17=5;
                }
                break;
            case 60:
                {
                alt17=6;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 17, 0, input);

                throw nvae;
            }

            switch (alt17) {
                case 1 :
                    // RiseCollectionFormulaClientAST.g:293:10: DecimalLiteral
                    {
                    DecimalLiteral7=(CommonTree)match(input,DecimalLiteral,FOLLOW_DecimalLiteral_in_literal874); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                      out((DecimalLiteral7!=null?DecimalLiteral7.getText():null));
                    }

                    }
                    break;
                case 2 :
                    // RiseCollectionFormulaClientAST.g:294:10: FloatingPointLiteral
                    {
                    match(input,FloatingPointLiteral,FOLLOW_FloatingPointLiteral_in_literal886); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    // RiseCollectionFormulaClientAST.g:295:10: CharacterLiteral
                    {
                    match(input,CharacterLiteral,FOLLOW_CharacterLiteral_in_literal897); if (state.failed) return ;

                    }
                    break;
                case 4 :
                    // RiseCollectionFormulaClientAST.g:296:10: StringLiteral
                    {
                    match(input,StringLiteral,FOLLOW_StringLiteral_in_literal908); if (state.failed) return ;

                    }
                    break;
                case 5 :
                    // RiseCollectionFormulaClientAST.g:297:10: booleanLiteral
                    {
                    pushFollow(FOLLOW_booleanLiteral_in_literal919);
                    booleanLiteral();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 6 :
                    // RiseCollectionFormulaClientAST.g:298:10: 'null'
                    {
                    match(input,60,FOLLOW_60_in_literal930); if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "literal"


    // $ANTLR start "booleanLiteral"
    // RiseCollectionFormulaClientAST.g:301:1: booleanLiteral : ( 'true' | 'false' );
    public final void booleanLiteral() throws RecognitionException {
        try {
            // RiseCollectionFormulaClientAST.g:302:5: ( 'true' | 'false' )
            // RiseCollectionFormulaClientAST.g:
            {
            if ( (input.LA(1)>=61 && input.LA(1)<=62) ) {
                input.consume();
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "booleanLiteral"

    // Delegated rules


 

    public static final BitSet FOLLOW_statement_in_prog56 = new BitSet(new long[]{0x00000200200052A0L});
    public static final BitSet FOLLOW_ENDPROG_in_prog59 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ifStatement_in_statement70 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FOR_in_statement76 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_inListStatement_in_statement78 = new BitSet(new long[]{0x00000200200052A8L});
    public static final BitSet FOLLOW_statement_in_statement80 = new BitSet(new long[]{0x00000200200052A8L});
    public static final BitSet FOLLOW_FOREACH_in_statement90 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_statement_in_statement106 = new BitSet(new long[]{0x00000200200052A8L});
    public static final BitSet FOLLOW_assignStatement_in_statement122 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_asAssignStatement_in_statement127 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_functionStatement_in_statement132 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IF_in_ifStatement147 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expression_in_ifStatement151 = new BitSet(new long[]{0x0000020020005AA8L});
    public static final BitSet FOLLOW_statement_in_ifStatement155 = new BitSet(new long[]{0x0000020020005AA8L});
    public static final BitSet FOLLOW_elseStatement_in_ifStatement160 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_ELSE_in_elseStatement177 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_statement_in_elseStatement179 = new BitSet(new long[]{0x00000200200052A8L});
    public static final BitSet FOLLOW_41_in_assignStatement194 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_assignkeywords_in_assignStatement198 = new BitSet(new long[]{0x0000000003E00000L});
    public static final BitSet FOLLOW_referenceassign_in_assignStatement202 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_Identifier_in_asAssignStatement222 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_Identifier_in_asAssignStatement226 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_SURE_in_functionStatement245 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expression_in_functionStatement264 = new BitSet(new long[]{0x0000000000008000L});
    public static final BitSet FOLLOW_StringLiteral_in_functionStatement268 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_IN_in_inListStatement287 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_Identifier_in_inListStatement289 = new BitSet(new long[]{0x0000000000040000L});
    public static final BitSet FOLLOW_TO_in_inListStatement292 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_DecimalLiteral_in_inListStatement296 = new BitSet(new long[]{0x0000000000020000L});
    public static final BitSet FOLLOW_DecimalLiteral_in_inListStatement300 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_DecimalLiteral_in_inListStatement305 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_IN_in_inListStatement317 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_Identifier_in_inListStatement319 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_DECINODE_in_inListStatement322 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_DecimalLiteral_in_inListStatement324 = new BitSet(new long[]{0x0000000000020008L});
    public static final BitSet FOLLOW_47_in_expression344 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expression_in_expression346 = new BitSet(new long[]{0x7FFF84031FFA9000L});
    public static final BitSet FOLLOW_expression_in_expression350 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_48_in_expression357 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expression_in_expression359 = new BitSet(new long[]{0x7FFF84031FFA9000L});
    public static final BitSet FOLLOW_expression_in_expression363 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_49_in_expression370 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expression_in_expression372 = new BitSet(new long[]{0x7FFF84031FFA9000L});
    public static final BitSet FOLLOW_expression_in_expression376 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_51_in_expression383 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expression_in_expression385 = new BitSet(new long[]{0x7FFF84031FFA9000L});
    public static final BitSet FOLLOW_expression_in_expression389 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_52_in_expression396 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expression_in_expression398 = new BitSet(new long[]{0x7FFF84031FFA9000L});
    public static final BitSet FOLLOW_expression_in_expression402 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_53_in_expression409 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expression_in_expression411 = new BitSet(new long[]{0x7FFF84031FFA9000L});
    public static final BitSet FOLLOW_expression_in_expression415 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_54_in_expression422 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expression_in_expression424 = new BitSet(new long[]{0x7FFF84031FFA9000L});
    public static final BitSet FOLLOW_expression_in_expression428 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_50_in_expression435 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expression_in_expression437 = new BitSet(new long[]{0x7FFF84031FFA9000L});
    public static final BitSet FOLLOW_expression_in_expression441 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_55_in_expression448 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expression_in_expression450 = new BitSet(new long[]{0x7FFF84031FFA9000L});
    public static final BitSet FOLLOW_expression_in_expression454 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_56_in_expression462 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expression_in_expression464 = new BitSet(new long[]{0x7FFF84031FFA9000L});
    public static final BitSet FOLLOW_expression_in_expression468 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_57_in_expression475 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expression_in_expression477 = new BitSet(new long[]{0x7FFF84031FFA9000L});
    public static final BitSet FOLLOW_expression_in_expression481 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_58_in_expression490 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expression_in_expression492 = new BitSet(new long[]{0x7FFF84031FFA9000L});
    public static final BitSet FOLLOW_expression_in_expression496 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_59_in_expression503 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expression_in_expression505 = new BitSet(new long[]{0x7FFF84031FFA9000L});
    public static final BitSet FOLLOW_expression_in_expression507 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_primary_in_expression513 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_parExpression_in_primary535 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LEN_in_primary545 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_assignkeywords_in_primary549 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_NOTEMPTY_in_primary568 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_assignkeywords_in_primary572 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_EMPTY_in_primary591 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_assignkeywords_in_primary595 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_Identifier_in_primary609 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_literal_in_primary618 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_reportkeywords_in_primary623 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_reference_in_primary628 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_INDICATIONCELL_in_assignkeywords648 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_RANGECELL_in_assignkeywords660 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_INDICATIONCELL_in_reportkeywords676 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_RANGECELL_in_reportkeywords689 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ZZJGDM_in_referenceassign712 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TBR_in_referenceassign722 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_BGQ_in_referenceassign734 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TBRQ_in_referenceassign746 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_QYMC_in_referenceassign756 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ZZJGDM_in_reference769 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TBR_in_reference779 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_BGQ_in_reference791 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TBRQ_in_reference803 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_QYMC_in_reference813 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_42_in_parExpression841 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expression_in_parExpression844 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_44_in_parExpression846 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_DecimalLiteral_in_literal874 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FloatingPointLiteral_in_literal886 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CharacterLiteral_in_literal897 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_StringLiteral_in_literal908 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_booleanLiteral_in_literal919 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_60_in_literal930 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_booleanLiteral0 = new BitSet(new long[]{0x0000000000000002L});

}